package com.gz.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.gz.dao.UserRoleMapper;
import com.gz.dto.PageData;
import com.gz.dto.UserRoleDto;
import com.gz.entity.UserRole;
import com.gz.service.UserRoleService;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 用户,角色关系表(UserRole)表服务实现类
 *
 * @author makejava
 * @since 2024-02-22 13:17:21
 */
@Service
public class UserRoleServiceImpl implements UserRoleService {

  @Autowired
  private UserRoleMapper userRoleDao;

  /**
   * 通过ID查询单条数据
   *
   * @param id 主键
   * @return 实例对象
   */
  @Override
  public UserRole queryById(Integer id) {
    return userRoleDao.queryById(id);
  }

  /**
   * 分页查询
   *
   * @param dto 筛选条件
   * @return 查询结果
   */
  @Override
  public PageData queryByPage(UserRoleDto dto) {
    PageHelper.startPage(dto.getPageNum(), dto.getPageSize());
    List<UserRole> list = userRoleDao.queryAll(dto);
    PageInfo<UserRole> pageInfo = new PageInfo<>(list);
    return new PageData<>(pageInfo.getTotal(), list);
  }

  /**
   * 分页查询
   *
   * @param dto 筛选条件
   * @return 查询结果
   */
  @Override
  public List<UserRole> queryAll(UserRoleDto dto) {
    List<UserRole> list = userRoleDao.queryAll(dto);
    return list;
  }

  /**
   * 新增数据
   *
   * @param userRole 实例对象
   * @return 实例对象
   */
  @Override
  public UserRole insert(UserRole userRole) {
    if (null != userRole.getUserId() && null != userRole.getRoleId()) {
      UserRoleDto dto = new UserRoleDto();
      dto.setUserId(userRole.getUserId());
      dto.setRoleId(userRole.getRoleId());
      List<UserRole> userRoles = userRoleDao.queryAll(dto);
      if (CollectionUtils.isNotEmpty(userRoles)) {
        userRole.setOptDt(new Date());
        userRoleDao.update(userRole);
      } else {
        userRoleDao.insert(userRole);
      }
    }
    return userRole;
  }

  /**
   * 修改数据
   *
   * @param userRole 实例对象
   * @return 实例对象
   */
  @Override
  public UserRole update(UserRole userRole) {
    userRoleDao.update(userRole);
    return queryById(userRole.getId());
  }

  /**
   * 批量修改数据
   *
   * @param list 实例对象
   * @return 实例对象
   */
  @Override
  public int updateBatch(List<UserRole> list) {
    for(UserRole item:list){
      item.setOptDt(new Date());
    }
    return userRoleDao.updateBatch(list);
  }

  /**
   * 批量修改数据
   *
   * @param list 实例对象
   * @return 实例对象
   */
  @Override
  public int insertBatch(List<UserRole> list) {
    /** 把所有用户角色关系按照用户分好组  */
    Map<Integer, List<UserRole>> typeMap = list.parallelStream()
        .collect(Collectors.groupingBy(a -> null == a.getUserId() ? 0 : a.getUserId()));
    Iterator<Entry<Integer, List<UserRole>>> iterator = typeMap.entrySet().iterator();
    /** 待新增用户角色关系数据  */
    List<UserRole> addData = new ArrayList<>();
    /** 遍历分好组的map，每一次为单个用户所有的想新增的用户关系 */
    while (iterator.hasNext()) {
      Map.Entry entry = iterator.next();
      Integer key = (Integer) entry.getKey();
      /** 拿到单个key用户想新增的所有角色关系 */
      List<UserRole> val = (List<UserRole>) entry.getValue();
      /** 校验角色关系集合是否为空 */
      if (null != key && !org.apache.commons.collections.CollectionUtils.isEmpty(val)) {
        /** 拿到单个用户待新增（未过滤）所有角色关系id   */
        List<Integer> itmRoleIds = val.stream().map(a -> {
          return a.getRoleId();
        }).distinct().collect(Collectors.toList());
        /** 查询该单个用户之前所有角色关系id   */
        UserRoleDto userRoleDto = new UserRoleDto();
        userRoleDto.setUserId(key);
        /** 单个用户之前所有的角色关系 */
        List<UserRole> existUserRoles = userRoleDao.queryAll(userRoleDto);
        /** 单个用户之前所有的角色关系id */
        List<Integer> existRoleIds = existUserRoles.stream().map(a -> {
          return a.getRoleId();
        }).distinct().collect(Collectors.toList());
        /** 拿出该单个用户不包含的角色关系 */
        for(Integer itmRoleId:itmRoleIds){
          /** 待新增用户角色关系过滤已存在用户角色关系，保留未存在新增用户角色关系 */
          if(!existRoleIds.contains(itmRoleId)){
            UserRole userRole = new UserRole();
            userRole.setUserId(key);
            userRole.setRoleId(itmRoleId);
            userRole.setCrtDt(new Date());
            userRole.setOptDt(new Date());
            addData.add(userRole);
          }
        }
      }
    }
    int i=0;
    if(CollectionUtils.isNotEmpty(addData)){
       i = userRoleDao.insertBatch(addData);
    }
    return i;
  }

  /**
   * 通过主键删除数据
   *
   * @param id 主键
   * @return 是否成功
   */
  @Override
  public boolean deleteById(Integer id) {
    return userRoleDao.deleteById(id) > 0;
  }
}
